package com.survey.project.research.service.impl;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.IntFunction;
import java.util.stream.IntStream;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.survey.common.exception.CustomException;
import com.survey.common.utils.DateUtils;
import com.survey.common.utils.OrangeUtils;
import com.survey.common.utils.StringUtils;
import com.survey.project.research.domain.*;
import com.survey.project.research.domain.vo.*;
import com.survey.project.research.mapper.*;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import com.survey.project.research.service.IQuestionnaireService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 调研问卷Service业务层处理
 *
 * @author survey
 * @date 2021-05-20
 */
@RequiredArgsConstructor
@Service
public class QuestionnaireServiceImpl implements IQuestionnaireService {

    private final QuestionnaireMapper questionnaireMapper;

    private final QuestionChoiceMapper questionChoiceMapper;

    private final QuestionnaireQuestionMapper questionnaireQuestionMapper;

    private final ConsumerMapper consumerMapper;

    private final ConsumerAnswerMapper consumerAnswerMapper;

    /**
     * 查询调研问卷
     *
     * @param questionnaireId 调研问卷ID
     * @return 调研问卷
     */
    @Override
    public Questionnaire selectQuestionnaireById(Long questionnaireId) {
        return questionnaireMapper.selectQuestionnaireById(questionnaireId);
    }

    /**
     * 查询调研问卷列表
     *
     * @param questionnaire 调研问卷
     * @return 调研问卷
     */
    @Override
    public List<Questionnaire> selectQuestionnaireList(Questionnaire questionnaire) {
        return questionnaireMapper.selectQuestionnaireList(questionnaire);
    }

    /**
     * 新增调研问卷
     *
     * @param questionnaire 调研问卷
     * @return 结果
     */
    @Override
    public int insertQuestionnaire(Questionnaire questionnaire) {
        this.checkQuestionnaireNo(questionnaire);
        questionnaire.setCreateTime(DateUtils.getNowDate());
        return questionnaireMapper.insertQuestionnaire(questionnaire);
    }

    /**
     * 修改调研问卷
     *
     * @param questionnaire 调研问卷
     * @return 结果
     */
    @Override
    public int updateQuestionnaire(Questionnaire questionnaire) {
        this.checkQuestionnaireNo(questionnaire);
        questionnaire.setUpdateTime(DateUtils.getNowDate());
        return questionnaireMapper.updateQuestionnaire(questionnaire);
    }

    /**
     * 问卷编号不能重复
     */
    public void checkQuestionnaireNo(Questionnaire questionnaire) {
        Questionnaire result = questionnaireMapper.selectOne(new QueryWrapper<Questionnaire>().lambda()
                .eq(Questionnaire::getQuestionnaireNo, questionnaire.getQuestionnaireNo())
                .eq(Questionnaire::getDelFlag, 0));
        if (result != null) {
            if (questionnaire.getQuestionnaireId() == null || !result.getQuestionnaireId().equals(questionnaire.getQuestionnaireId())) {
                throw new CustomException("问卷编号已存在！");
            }
        }
    }

    /**
     * 批量删除调研问卷
     *
     * @param questionnaireIds 需要删除的调研问卷ID
     * @return 结果
     */
    @Override
    public int deleteQuestionnaireByIds(Long[] questionnaireIds) {
        return questionnaireMapper.deleteQuestionnaireByIds(questionnaireIds);
    }

    /**
     * 删除调研问卷信息
     *
     * @param questionnaireId 调研问卷ID
     * @return 结果
     */
    @Override
    public int deleteQuestionnaireById(Long questionnaireId) {
        return questionnaireMapper.deleteQuestionnaireById(questionnaireId);
    }

    @Override
    public List<QuestionnaireQuestionListOutVo> researchQuestionnaireQuestionList(Long questionnaireId) {
        return questionnaireMapper.researchQuestionnaireQuestionList(questionnaireId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String importQuestion(List<QuestionnaireQuestionExcelVo> questionList, boolean updateSupport, String
            operName) {
        if (StringUtils.isNull(questionList) || questionList.size() == 0) {
            throw new CustomException("导入问题数据不能为空！");
        }
        // 查询问卷编号是否存在
        Questionnaire questionnaire = questionnaireMapper.selectOne(new QueryWrapper<Questionnaire>().eq("questionnaire_no", questionList.get(0).getQuestionnaireNo()));
        if (questionnaire == null) {
            throw new CustomException("未找到对应问卷编号！");
        }
        // 删除该问卷编号原问题和选项
        questionnaireQuestionMapper.delete(new QueryWrapper<QuestionnaireQuestion>().lambda()
                .eq(QuestionnaireQuestion::getQuestionnaireId, questionnaire.getQuestionnaireId()));
        questionChoiceMapper.delete(new QueryWrapper<QuestionChoice>().lambda()
                .eq(QuestionChoice::getQuestionnaireId, questionnaire.getQuestionnaireId()));
        int successNum = 0;
        StringBuilder successMsg = new StringBuilder();
        for (QuestionnaireQuestionExcelVo questionExcelVo : questionList) {
            // 封装问题信息
            QuestionnaireQuestion questionnaireQuestion = new QuestionnaireQuestion();
            questionnaireQuestion.setQuestionnaireId(questionnaire.getQuestionnaireId());
            questionnaireQuestion.setQuestionType(questionExcelVo.getQuestionType());
            questionnaireQuestion.setQuestionContent(questionExcelVo.getQuestionContent());
            questionnaireQuestion.setQuestionNo(questionExcelVo.getQuestionNo());
            questionnaireQuestion.setPNo(questionExcelVo.getPNo());
            if (questionExcelVo.getPNo() == null){
                throw new CustomException("导入失败!第" + (successNum + 2) + "行的父级序号不能为空！");
            }
            if (questionExcelVo.getPNo() == 0) {
                // 所有父级为0
                questionnaireQuestion.setPNos("0");
            } else {
                QuestionnaireQuestion resultQuestion = questionnaireQuestionMapper.selectOne(new QueryWrapper<QuestionnaireQuestion>().lambda()
                        .eq(QuestionnaireQuestion::getQuestionnaireId, questionnaire.getQuestionnaireId())
                        .eq(QuestionnaireQuestion::getQuestionNo, questionExcelVo.getPNo()));
                questionnaireQuestion.setPNos(resultQuestion.getPNos() + "," + questionnaireQuestion.getPNo());
            }
            questionnaireQuestion.setIsCheckDesc(questionExcelVo.getIsCheckDesc());
            questionnaireQuestionMapper.insert(questionnaireQuestion);
            // 是否为选择题进行选项插入
            if(questionExcelVo.getQuestionType()==null){
                throw new CustomException("导入失败!第" + (successNum + 2) + "行的问题类型不能为空！");
            }
            if (questionExcelVo.getQuestionType() == 1 || questionExcelVo.getQuestionType() == 3) {
                if (questionExcelVo.getChoices().isEmpty()) {
                    throw new CustomException("导入失败!第" + (successNum + 2) + "行的选项不能为空！");
                }
                // 选项集合
                String[] choiceContents = questionExcelVo.getChoices().split(";");
                // 选项关联结合
                int[] choiceNos = null;
                if (StringUtils.isNotBlank(questionExcelVo.getChoiceNos())) {
                    choiceNos = OrangeUtils.stringsToInts(questionExcelVo.getChoiceNos().split(";"));
                }
                for (int i = 0; i < choiceContents.length; i++) {
                    QuestionChoice questionChoice = new QuestionChoice();
                    questionChoice.setQuestionnaireId(questionnaireQuestion.getQuestionnaireId());
                    questionChoice.setQuestionId(questionnaireQuestion.getQuestionId());
                    questionChoice.setChoiceContent(choiceContents[i]);
                    if (choiceNos != null) {
                        int j = i + 1;
                        boolean b = Arrays.stream(choiceNos).anyMatch(x -> x == j);
                        if (b) {
                            questionChoice.setRelationFlag("1");
                        } else {
                            questionChoice.setRelationFlag("0");
                        }
                    }
                    // 判断多选题是否有简答框
                    if ("1".equals(questionExcelVo.getIsCheckDesc())&&i==choiceContents.length-1){
                        questionChoice.setCheckDescFlag("1");
                    } else {
                        questionChoice.setCheckDescFlag("0");
                    }
                    questionChoiceMapper.insert(questionChoice);
                }
//                for (String choiceContent : choiceContents) {
//                    QuestionChoice questionChoice = new QuestionChoice();
//                    questionChoice.setQuestionnaireId(questionnaireQuestion.getQuestionnaireId());
//                    questionChoice.setQuestionId(questionnaireQuestion.getQuestionId());
//                    questionChoice.setChoiceContent(choiceContent);
//                    // 是否有关联子题目并默认第一个选项为关联其他问题选项
//                    if (!"".equals(questionExcelVo.getFlag()) && choiceContents[0].equals(choiceContent)){
//                        questionChoice.setRelationFlag("1");
//                    } else {
//                        questionChoice.setRelationFlag("0");
//                    }
//                    questionChoiceMapper.insert(questionChoice);
//                }
            }
            successNum++;
        }
        successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        return successMsg.toString();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String importConsumer(List<ConsumerExcelVo> consumerList, boolean updateSupport, String operName) {
        if (StringUtils.isNull(consumerList) || consumerList.size() == 0) {
            throw new CustomException("导入客户数据不能为空！");
        }
        // 查询问卷编号是否存在
        Questionnaire questionnaire = questionnaireMapper.selectOne(new QueryWrapper<Questionnaire>().eq("questionnaire_no", consumerList.get(0).getQuestionnaireNo()));
        if (questionnaire == null) {
            throw new CustomException("未找到对应问卷编号！");
        }
        int successNum = 0;
        StringBuilder successMsg = new StringBuilder();
        for (ConsumerExcelVo consumerExcelVo : consumerList) {
            // 封装问题信息
            Consumer consumer = new Consumer();
            BeanUtils.copyProperties(consumerExcelVo, consumer);
            consumer.setQuestionnaireId(questionnaire.getQuestionnaireId());
            consumerMapper.insert(consumer);
            successNum++;
        }
        successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        return successMsg.toString();
    }

    @Override
    public List<ConsumerOutVo> researchQuestionnaireConsumerList(Questionnaire questionnaire) {
        return consumerMapper.selectConsumerListByQuestionnaireId(questionnaire.getQuestionnaireId());
    }

    @Override
    public List<QuestionnaireQuestionListOutVo> consumerQuestions(Long consumerId) {
        List<QuestionnaireQuestionListOutVo> list = questionnaireMapper.consumerQuestions(consumerId);
        for (QuestionnaireQuestionListOutVo questionnaireQuestionListOutVo : list) {
            for (QuestionChoiceListOutVo questionChoiceListOutVo : questionnaireQuestionListOutVo.getChoiceList()) {
                questionChoiceListOutVo.setQuestionNo(questionnaireQuestionListOutVo.getQuestionNo());
            }
        }
        return list;
    }

    @Override
    public void consumerCommit(ConsumerAnswerInVo inVo) {
        // 查询客户是否重复提交
        Consumer consumer = consumerMapper.selectById(inVo.getConsumerId());
        if ("1".equals(consumer.getQuestionnaireStatus())) {
            throw new CustomException("已提交过问卷,可直接关闭页面！");
        }
        // 根据客户id获取问卷id
        Long questionnaireId = questionnaireMapper.getQuestionnaireIdByConsumerId(inVo.getConsumerId());
        // 插入客户答案
        for (int i = 0; i < inVo.getAnswers().size(); i++) {
            if (inVo.getAnswers().get(i) != null && !Objects.equals(inVo.getAnswers().get(i).toString(), "")) {
                ConsumerAnswer consumerAnswer = new ConsumerAnswer();
                consumerAnswer.setQuestionnaireId(questionnaireId);
                consumerAnswer.setConsumerId(inVo.getConsumerId());
                consumerAnswer.setQuestionId(inVo.getQuestionIds().get(i));
                QuestionnaireQuestion questionnaireQuestion = questionnaireQuestionMapper.selectQuestionnaireQuestionById(consumerAnswer.getQuestionId());
                if (questionnaireQuestion.getQuestionType() == 1 || questionnaireQuestion.getQuestionType() == 4) {
                    // 单选或简答
                    consumerAnswer.setConsumerAnswer(inVo.getAnswers().get(i).toString());
                }
                if (questionnaireQuestion.getQuestionType() == 3) {
                    // 多选
                    String s = inVo.getAnswers().get(i).toString();
                    consumerAnswer.setConsumerAnswer(s.substring(1, s.length() - 1));
                    // 多选描述
                    if (inVo.getCheckDescList().get(i)!=null){
                        consumerAnswer.setCheckDesc(inVo.getCheckDescList().get(i));
                    }
                }
                consumerAnswerMapper.insertConsumerAnswer(consumerAnswer);
            }
        }
        // 修改客户问卷填写状态
        consumer.setQuestionnaireStatus("1");
        consumerMapper.updateById(consumer);
        // 问卷提交人数增加
        Questionnaire questionnaire = questionnaireMapper.selectOne(new QueryWrapper<Questionnaire>().lambda().eq(Questionnaire::getQuestionnaireId, consumer.getQuestionnaireId()));
        questionnaire.setCommitTotal(questionnaire.getCommitTotal() + 1);
        questionnaireMapper.updateById(questionnaire);
    }

    @Override
    public QuestionChoiceListOutVo getChoiceByChoiceId(Long choiceId) {
        QuestionChoiceListOutVo outVo = questionnaireMapper.getChoiceByChoiceId(choiceId);
        // 打开子题目(只打开下一级的子题目)
        Long questionnaireId = questionnaireMapper.getQuestionnaireIdByChoiceId(choiceId);
        // 判断是打开子题目还是关闭自题目
        if ("1".equals(outVo.getRelationFlag())) {
            List<QuestionnaireQuestion> questions = questionnaireQuestionMapper.selectList(new QueryWrapper<QuestionnaireQuestion>().lambda()
                    .eq(QuestionnaireQuestion::getQuestionnaireId, questionnaireId)
                    .eq(QuestionnaireQuestion::getPNo, outVo.getQuestionNo()));
            if (questions != null && questions.size() > 0) {
                ArrayList<Long> childQuestionNoList = new ArrayList<>();
                for (QuestionnaireQuestion question : questions) {
                    childQuestionNoList.add(question.getQuestionNo());
                }
                outVo.setChildQuestionNoList(childQuestionNoList);
            }
        } else if ("0".equals(outVo.getRelationFlag())) {
            // 关闭子题目(包括子题目的子题目)
            List<QuestionnaireQuestion> questions = questionnaireQuestionMapper.selectList(new QueryWrapper<QuestionnaireQuestion>().lambda()
                    .eq(QuestionnaireQuestion::getQuestionnaireId, questionnaireId)
                    .like(QuestionnaireQuestion::getPNos, String.valueOf(outVo.getQuestionNo())));
            if (questions != null && questions.size() > 0) {
                ArrayList<Long> childQuestionNoList = new ArrayList<>();
                for (QuestionnaireQuestion question : questions) {
                    childQuestionNoList.add(question.getQuestionNo());
                }
                outVo.setChildQuestionNoList(childQuestionNoList);
            }
        }
        return outVo;
    }

    @Override
    public QuestionChoiceCheckListOutVo getChoiceCheckByChoiceId(Long choiceId) {
        QuestionChoiceCheckListOutVo outVo = new QuestionChoiceCheckListOutVo();
        QuestionChoice questionChoice = questionChoiceMapper.selectById(choiceId);
        if (questionChoice!=null){
            outVo.setCheckDescFlag(questionChoice.getCheckDescFlag());
            QuestionnaireQuestion question = questionnaireQuestionMapper.selectById(questionChoice.getQuestionId());
            if (question!=null){
                outVo.setQuestionNo(question.getQuestionNo());
            }
        }
        return outVo;
    }

    @Override
    public List<List<String>> getQuestionListByQuestionnaireId(Long questionnaireId) {
        List<List<String>> headLists = new ArrayList<>();
        List<QuestionnaireQuestion> questions = questionnaireQuestionMapper.selectList(new QueryWrapper<QuestionnaireQuestion>()
                .lambda()
                .eq(QuestionnaireQuestion::getQuestionnaireId, questionnaireId).orderByAsc(QuestionnaireQuestion::getQuestionNo));
        ArrayList<String> headTitle0 = new ArrayList<>();
        ArrayList<String> headTitle1 = new ArrayList<>();
        headTitle0.add("问题数");
        headTitle1.add("vin");
        headLists.add(headTitle0);
        headLists.add(headTitle1);
        for (QuestionnaireQuestion question : questions) {
            ArrayList<String> headTitle = new ArrayList<>();
            headTitle.add(question.getQuestionNo() + "." + question.getQuestionContent());
            headLists.add(headTitle);
        }
        return headLists;
    }

    @Override
    public List<List<Object>> getConsumerAnswerByQuestionnaireId(Long questionnaireId) {
        List<List<Object>> dataLists = new ArrayList<>();
        List<Consumer> consumers = consumerMapper.selectList(new QueryWrapper<Consumer>().lambda().eq(Consumer::getQuestionnaireId, questionnaireId).eq(Consumer::getQuestionnaireStatus, 1));
        for (Consumer consumer : consumers) {
            ArrayList<Object> datas = new ArrayList<>();
            datas.add("");
            datas.add(consumer.getVin());
            // 根据客户id查询答题结果
            List<ConsumerAnswerVo> consumerAnswers = consumerAnswerMapper.getConsumerAnswerByConsumerId(consumer.getConsumerId());
            for (ConsumerAnswerVo item : consumerAnswers) {
                StringBuilder answer = new StringBuilder();
                if (item.getQuestionType() == 4) {
                    // 简答题
                    if (item.getConsumerAnswer() != null) {
                        answer.append(item.getConsumerAnswer());
                    }
                    datas.add(answer.toString());
                } else if (item.getQuestionType() == 1) {
                    // 单选题
                    if (item.getConsumerAnswer() != null) {
                        // 根据答案id查询答案详情
                        QuestionChoice questionChoice = questionChoiceMapper.selectById(item.getConsumerAnswer());
                        answer.append(questionChoice.getChoiceContent());
                    }
                    datas.add(answer.toString());
                } else if (item.getQuestionType() == 3) {
                    // 多选题
                    if (item.getConsumerAnswer() != null) {
                        String[] strings = item.getConsumerAnswer().split(",");
                        for (int i = 0; i < strings.length; i++) {
                            // 根据答案id查询答案详情
                            QuestionChoice questionChoice = questionChoiceMapper.selectById(strings[i]);
                            answer.append(questionChoice.getChoiceContent());
                            if (i != strings.length - 1) {
                                answer.append(";");
                            }
                        }
                    }
                    datas.add(answer.toString());
                }
            }
            dataLists.add(datas);
        }
        return dataLists;
    }

    @Override
    public int changeQuestionnaireStatus(Questionnaire questionnaire) {
        return questionnaireMapper.updateById(questionnaire);
    }
}
